import { Controller } from "../../mvc/core/Controller";
import { Dispatcher } from "../../mvc/core/Dispatcher";
import { Game } from "../Game";
import { SActiveToClient } from "../../../Message/Public/SActiveToClient";
import { DataEvent } from "../events/DataEvent";
import { EventName } from "../mvc/EventName";
import { NetDispatcher } from "../../mvc/core/NetDispatcher";
import { ServerCommand } from "../mvc/ServerCommand";
import { IView } from "../../mvc/interfaces/IView";
import { LoveTaskModule } from "../../../modules/LoveTaskModule";
import { WindowEvent } from "../../component/window/WindowEvent";
import { HintIcon } from "../view/uiIconBtn/HintIcon";
import { ImagesConst } from "../resource/ImagesConst";
import { UiHintIconView } from "../view/uiIconBtn/UiHintIconView";
import { EffectManager } from "../manager/EffectManager";
import { UIIconEvent } from "../view/uiIconBtn/UIIconEvent";
import { ETaskGroup } from "../../../Message/Game/ETaskGroup";
import { ILoveTaskModule } from "../../../modules/interfaces/ILoveTaskModule";
import { LoveTaskInviteModule } from "../../../modules/LoveTaskInviteModule";
import { SPublicMiniPlayer } from "../../../Message/Public/SPublicMiniPlayer";
import { LoveTaskCommentResModule } from "../../../modules/LoveTaskCommentResModule";
import { EActiveType } from "../../../Message/Public/EActiveType";
import { GameProxy } from "../mvc/GameProxy";
import { LoveTaskGiveItemInfo } from "../model/loveTask/LoveTaskGiveItemInfo";
import { LoveTaskCommentInfo } from "../model/loveTask/LoveTaskCommentInfo";
import { TaskInfo } from "../model/TaskInfo";
import { ETaskStatus } from "../../../Message/Game/ETaskStatus";
import { MsgManager } from "../manager/MsgManager";
import { Language } from "../../../extend/language/Language";
import { HTMLUtil } from "../../../com/gengine/utils/HTMLUtil";
import { ColorConfig } from "../resource/ColorConfig";
import { STask } from "../../../Message/Game/STask";
import { SPartnerReply } from "../../../Message/Game/SPartnerReply";
import { ILoveTaskInviteModule } from "../../../modules/interfaces/ILoveTaskInviteModule";
import { ILoveTaskCommentResModule } from "../../../modules/interfaces/ILoveTaskCommentResModule";
type int = number;
//class LoveTaskController
    
    export  class LoveTaskController extends Controller
    {
        constructor()
        {
            
            super();Dispatcher.addEventListener("showGiveItemView", this.showGif);
            return;
        }

        /* internal  */onEffectEndRes(arg1: Object): void
        {
            if (Game.isSceneInit()) 
            {
                Game.scene.udpateEffectIsAddToStage(cache.loveTask.sceneEffectId, false, 400101);
            }
            return;
        }

        /* internal  */onActiveLoveAddZazenHandler(arg1: SActiveToClient): void
        {
            if (this._hintIcon) 
            {
                this._hintIcon.updateActiveToClientInfo(arg1);
            }
            return;
        }

        /* internal  */onLoginGameSuccessHandler(arg1: DataEvent): void
        {
            Game.scene.udpateEffectIsAddToStage(cache.loveTask.sceneEffectId, cache.loveTask.effectShow, 400101);
            Dispatcher.removeEventListener(EventName.Scene_Update, this.onLoginGameSuccessHandler);
            return;
        }

        /* internal  */onLoveTaskToPlayerGiveItemRes(arg1: DataEvent): void
        {
            this.showGotoView(cache.loveTask.isStartPlayer);
            return;
        }

        protected /* override */ initServer(): void
        {
            super.initServer();
            Dispatcher.addEventListener(EventName.LoveTaskTarget, this.onLoveTaskTargetReq);
            Dispatcher.addEventListener(EventName.Scene_Update, this.onLoginGameSuccessHandler);
            Dispatcher.addEventListener(EventName.LoveTaskToPlayerGiveItemRes, this.onLoveTaskToPlayerGiveItemRes);
            NetDispatcher.addCmdListener(ServerCommand.TaskGetRes, this.onTaskGetRes);
            NetDispatcher.addCmdListener(ServerCommand.TaskListRes, this.onTaskListRes);
            NetDispatcher.addCmdListener(ServerCommand.TaskUpdate, this.onTaskUpdateRes);
            NetDispatcher.addCmdListener(ServerCommand.TaskEndRes, this.onTaskEndRes);
            NetDispatcher.addCmdListener(ServerCommand.TaskCancelRes, this.onTaskCancelRes);
            NetDispatcher.addCmdListener(ServerCommand.FriendListUpdate, this.onFriendListRes);
            NetDispatcher.addCmdListener(ServerCommand.LoveTaskFindPartner, this.onFindPartnerRes);
            NetDispatcher.addCmdListener(ServerCommand.LoveTaskPartnerInfo, this.onPartnerInfoRes);
            NetDispatcher.addCmdListener(ServerCommand.LoveTaskInvitePartner, this.onInvitePartnerRes);
            NetDispatcher.addCmdListener(ServerCommand.LoveTaskPartnerReply, this.onPartnerReplyRes);
            NetDispatcher.addCmdListener(ServerCommand.LoveTaskPartnerStart, this.onPartnerStartRes);
            NetDispatcher.addCmdListener(ServerCommand.LoveTaskPartnerEnd, this.onPartnerEndRes);
            NetDispatcher.addCmdListener(ServerCommand.LoveTaskPartnerSendItem, this.onPartnerSentItemRes);
            NetDispatcher.addCmdListener(ServerCommand.LoveTaskPartnerComment, this.onPartnerCommentRes);
            NetDispatcher.addCmdListener(ServerCommand.LoveTaskEffectStart, this.onEffectStartRes);
            NetDispatcher.addCmdListener(ServerCommand.LoveTaskEffectEnd, this.onEffectEndRes);
            NetDispatcher.addCmdListener(ServerCommand.ActiveLoveAddZazen, this.onActiveLoveAddZazenHandler);
            Dispatcher.addEventListener(EventName.LoveTaskFindReq, this.onLoveTaskFindReq);
            Dispatcher.addEventListener(EventName.LoveTaskInviteReq, this.onLoveTaskInviteReq);
            Dispatcher.addEventListener(EventName.LoveTaskGiveReq, this.onLoveTaskGiveReq);
            Dispatcher.addEventListener(EventName.LoveTaskInviteOk, this.onLoveTaskInviteOkHandler);
            Dispatcher.addEventListener(EventName.LoveTaskInviteNo, this.onLoveTaskInviteNoHandler);
            Dispatcher.addEventListener(EventName.LoveTaskInviteNoAll, this.onLoveTaskInviteNoAllHandler);
            Dispatcher.addEventListener(EventName.LoveTaskCommentReq, this.onLoveTaskCommentReq);
            return;
        }

        protected /* override */ initView(): IView
        {
            _view = new LoveTaskModule();
            _view.addEventListener(WindowEvent.SHOW, this.onViewShowHandler);
            _view.addEventListener(WindowEvent.CLOSE, this.onViewCloseHandler);
            return _view;
        }

        /* internal  */showGif(arg1: Object /* flash.events.Event */): void
        {
            this.showGiveItemView();
            return;
        }

        /* internal  */showHintIcon(arg1: Boolean=false): void
        {
            if (!this._hintIcon) 
            {
                this._hintIcon = new HintIcon(ImagesConst.LoveTaskIcon);
                this._hintIcon.addEventListener(flash.events.MouseEvent.CLICK, this.onHintIconClickHandler);
            }
            if (!this._hintIcon.parent) 
            {
                UiHintIconView.instance.addHintIcon(this._hintIcon, arg1);
            }
            return;
        }

        /* internal  */hideHintIcon(): void
        {
            if (this._hintIcon && this._hintIcon.parent) 
            {
                this._hintIcon.parent.removeChild(this._hintIcon);
                EffectManager.glowFilterUnReg(this._hintIcon);
                this._hintIcon.dispatchEvent(new UIIconEvent(UIIconEvent.RemoveIcon));
            }
            return;
        }

        /* internal  */showInviteIcon(): void
        {
            if (cache.loveTask.invitePlayers.length != 0) 
            {
                if (!this._inviteIcon) 
                {
                    this._inviteIcon = new HintIcon(ImagesConst.LoveTaskInviteIcon);
                    this._inviteIcon.addEventListener(flash.events.MouseEvent.CLICK, this.onInviteIconClickHandler);
                }
                if (!this._inviteIcon.parent) 
                {
                    UiHintIconView.instance.addHintIcon(this._inviteIcon);
                }
                this._inviteIcon.labelTxt = cache.loveTask.invitePlayers.length.toString();
            }
            return;
        }

        /* internal  */hideInviteIcon(): void
        {
            if (this._inviteIcon && this._inviteIcon.parent) 
            {
                this._inviteIcon.parent.removeChild(this._inviteIcon);
                EffectManager.glowFilterUnReg(this._inviteIcon);
                this._inviteIcon.dispatchEvent(new UIIconEvent(UIIconEvent.RemoveIcon));
            }
            return;
        }

        /* internal  */showCommentIcon(): void
        {
            if (!this._commentIcon) 
            {
                this._commentIcon = new HintIcon(ImagesConst.LoveTaskCommentIcon);
                this._commentIcon.addEventListener(flash.events.MouseEvent.CLICK, this.onCommentIconClickHandler);
            }
            if (!this._commentIcon.parent) 
            {
                UiHintIconView.instance.addHintIcon(this._commentIcon, true);
            }
            this._commentIcon.labelTxt = cache.loveTask.getCommentRes(false).length.toString();
            return;
        }

        /* internal  */hideCommentIcon(): void
        {
            if (this._commentIcon && this._commentIcon.parent) 
            {
                this._hintIcon.parent.removeChild(this._commentIcon);
                EffectManager.glowFilterUnReg(this._commentIcon);
                this._commentIcon.dispatchEvent(new UIIconEvent(UIIconEvent.RemoveIcon));
            }
            return;
        }

        /* internal  */onViewCloseHandler(arg1: WindowEvent): void
        {
            var loc1=cache.task.getTaskByGroup(ETaskGroup._ETaskGroupLove);
            if (cache.loveTask.isStartPlayer || loc1.length > 0) 
            {
                if (!cache.loveTask.hasComment) 
                {
                    this.showHintIcon();
                }
            }
            else if (!cache.loveTask.endMsg) 
            {
                this.showHintIcon();
            }
            return;
        }

        /* internal  */onViewShowHandler(arg1: WindowEvent): void
        {
            this.hideHintIcon();
            return;
        }

        /* internal  */onInviteCloseHandler(arg1: WindowEvent): void
        {
            if (cache.loveTask.invitePlayers.length != 0) 
            {
                this.showInviteIcon();
            }
            return;
        }

        /* internal  */showFindView(): void
        {
            if (!isViewShow) 
            {
                view.show();
            }
            (_view as ILoveTaskModule).showFindView();
            return;
        }

        /* internal  */updateOnlinePlayer(): void
        {
            if (isViewShow) 
            {
                (_view as ILoveTaskModule).updateOnlinePlayer();
            }
            return;
        }

        /* internal  */updateFreeCount(): void
        {
            if (!isViewShow) 
            {
                return;
            }
            (_view as ILoveTaskModule).updateFreeCount();
            return;
        }

        /* internal  */showInviteView(): void
        {
            if (cache.loveTask.invitePlayers.length != 0) 
            {
                if (!this._inviteView) 
                {
                    this._inviteView = new LoveTaskInviteModule();
                    this._inviteView.addEventListener(WindowEvent.CLOSE, this.onInviteCloseHandler);
                }
                if (this._inviteView.isHide) 
                {
                    this._inviteView.show();
                }
                this._inviteView.updateData(cache.loveTask.invitePlayers);
            }
            return;
        }

        public addInviteView(arg1: SPublicMiniPlayer): void
        {
            if (this._inviteView && !this._inviteView.isHide) 
            {
                this._inviteView.addInvitePlayer(arg1);
            }
            return;
        }

        public delInviteView(arg1: SPublicMiniPlayer): void
        {
            if (this._inviteView && !this._inviteView.isHide) 
            {
                this._inviteView.delInvitePlayer(arg1);
            }
            return;
        }

        /* internal  */showGiveItemView(): void
        {
            if (!isViewShow) 
            {
                view.show();
            }
            (_view as ILoveTaskModule).showGiveItemView();
            return;
        }

        /* internal  */showGotoView(arg1: Boolean): void
        {
            if (!isViewShow) 
            {
                view.show();
            }
            (_view as ILoveTaskModule).showGotoView(arg1);
            return;
        }

        /* internal  */showCommendView(): void
        {
            if (!isViewShow) 
            {
                view.show();
            }
            (_view as ILoveTaskModule).showCommendView();
            return;
        }

        /* internal  */showCommentResView(): void
        {
            var loc1=cache.loveTask.getCommentRes();
            if (loc1.length > 0) 
            {
                if (!this._commentResView) 
                {
                    this._commentResView = new LoveTaskCommentResModule();
                }
                if (this._commentResView.isHide) 
                {
                    this._commentResView.show();
                }
                this._commentResView.updateComments(loc1);
            }
            return;
        }

        /* internal  */hideCommentResView(): void
        {
            if (this._commentResView && this._commentResView.isHide) 
            {
                this._commentResView.hide();
            }
            return;
        }

        /* internal  */onHintIconClickHandler(arg1: Object /* flash.events.MouseEvent */): void
        {
            if (cache.loveTask.isStartPlayer) 
            {
                if (cache.loveTask.toPlayer) 
                {
                    if (cache.loveTask.hasGiveItem) 
                    {
                        if (cache.loveTask.endMsg) 
                        {
                            if (!cache.loveTask.hasComment) 
                            {
                                this.showCommendView();
                            }
                        }
                        else 
                        {
                            this.showGotoView(true);
                        }
                    }
                    else 
                    {
                        this.showGiveItemView();
                    }
                }
                else 
                {
                    this.showFindView();
                }
            }
            else if (cache.loveTask.endMsg) 
            {
                this.showFindView();
            }
            else if (cache.loveTask.fromPlayer) 
            {
                if (cache.active.isActiveInEffect(EActiveType._EActiveTypeLoveGiffGaff) && !cache.loveTask.toPlayerGiveItem) 
                {
                    this.showGiveItemView();
                }
                else 
                {
                    this.showGotoView(false);
                }
            }
            else if (!cache.loveTask.toPlayer) 
            {
                this.showFindView();
            }
            return;
        }

        /* internal  */onInviteIconClickHandler(arg1: Object /* flash.events.MouseEvent */): void
        {
            this.showInviteView();
            return;
        }

        /* internal  */onCommentIconClickHandler(arg1: Object /* flash.events.MouseEvent */): void
        {
            this.showCommentResView();
            return;
        }

        /* internal  */onLoveTaskTargetReq(arg1: DataEvent): void
        {
            this.onHintIconClickHandler(null);
            return;
        }

        /* internal  */onLoveTaskFindReq(arg1: DataEvent): void
        {
            GameProxy.loveTask.findPartner(cache.loveTask.freeFlushCount > 0);
            return;
        }

        /* internal  */onLoveTaskInviteReq(arg1: DataEvent): void
        {
            var loc1=arg1.data as SPublicMiniPlayer;
            if (loc1) 
            {
                GameProxy.loveTask.invitePartner(loc1.entityId);
            }
            return;
        }

        /* internal  */onLoveTaskGiveReq(arg1: DataEvent): void
        {
            var loc1=arg1.data as LoveTaskGiveItemInfo;
            if (cache.loveTask.toPlayer) 
            {
                if (loc1) 
                {
                    GameProxy.loveTask.giveGiftToPartner(cache.loveTask.toPlayer.entityId, loc1.itemCode);
                }
                else 
                {
                    GameProxy.loveTask.giveGiftToPartner(cache.loveTask.toPlayer.entityId, -1);
                }
            }
            else if (cache.loveTask.fromPlayer) 
            {
                if (loc1) 
                {
                    GameProxy.loveTask.giveGiftToPartner(cache.loveTask.fromPlayer.entityId, loc1.itemCode);
                }
                else 
                {
                    GameProxy.loveTask.giveGiftToPartner(cache.loveTask.fromPlayer.entityId, -1);
                }
            }
            return;
        }

        /* internal  */onLoveTaskCommentReq(arg1: DataEvent): void
        {
            var loc1=null;
            if (cache.loveTask.toPlayer) 
            {
                loc1 = arg1.data as LoveTaskCommentInfo;
                if (loc1) 
                {
                    GameProxy.loveTask.evaluatePartner(cache.loveTask.toPlayer.entityId, loc1.code);
                }
            }
            return;
        }

        /* internal  */onLoveTaskInviteOkHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as SPublicMiniPlayer;
            if (loc1) 
            {
                GameProxy.loveTask.partnerReply(loc1.entityId, true);
            }
            return;
        }

        /* internal  */onLoveTaskInviteNoHandler(arg1: DataEvent): void
        {
            var loc1=arg1.data as SPublicMiniPlayer;
            if (loc1) 
            {
                cache.loveTask.delInvitePlayer(loc1);
                this.delInviteView(loc1);
                GameProxy.loveTask.partnerReply(loc1.entityId, false);
            }
            if (cache.loveTask.invitePlayers.length == 0) 
            {
                if (this._inviteView && !this._inviteView.isHide) 
                {
                    this._inviteView.hide();
                }
                this.hideInviteIcon();
            }
            return;
        }

        /* internal  */onLoveTaskInviteNoAllHandler(arg1: DataEvent): void
        {
            cache.loveTask.clearInvitePlayer();
            if (this._inviteView && !this._inviteView.isHide) 
            {
                this._inviteView.hide();
            }
            this.hideInviteIcon();
            return;
        }

        /* internal  */onTaskGetRes(arg1: Object): void
        {
            if (!arg1 || !arg1.task) 
            {
                return;
            }
            var loc1=arg1.task as TaskInfo;
            if (loc1.sTask.group == ETaskGroup._ETaskGroupLove) 
            {
                cache.loveTask.hasGiveItem = loc1.hasGiveItem;
                cache.loveTask.hasComment = loc1.hasComment;
                cache.loveTask.endMsg = false;
                this.showFindView();
            }
            return;
        }

        /* internal  */onTaskListRes(arg1: Object): void
        {
            var loc2=null;
            var loc1=cache.task.getTaskByGroup(ETaskGroup._ETaskGroupLove);
            if (loc1.length > 0) 
            {
                this._taskResType = 1;
                loc2 = loc1[0];
                cache.loveTask.hasGiveItem = loc2.hasGiveItem;
                cache.loveTask.hasComment = loc2.hasComment;
                cache.loveTask.endMsg = loc2.status == ETaskStatus._ETaskStatusHadCompleted;
                if (!cache.loveTask.hasComment) 
                {
                    if (!isViewShow) 
                    {
                        this.showHintIcon(true);
                    }
                }
            }
            else 
            {
                this._taskResType = -1;
            }
            return;
        }

        /* internal  */onTaskUpdateRes(arg1: Array<any>): void
        {
            var loc1=null;
            var loc2=0;
            var loc3=arg1.length;
            while (loc2 < loc3) 
            {
                loc1 = arg1[loc2];
                if (loc1.sTask.group == ETaskGroup._ETaskGroupLove) 
                {
                    break;
                }
                loc1 = null;
                ++loc2;
            }
            if (loc1) 
            {
                if (loc1.hasGiveItem) 
                {
                    if (!cache.loveTask.hasGiveItem) 
                    {
                        cache.loveTask.hasGiveItem = true;
                        this.showGotoView(true);
                    }
                }
                if (loc1.hasComment) 
                {
                    if (!cache.loveTask.hasComment) 
                    {
                        MsgManager.showRollTipsMsg(Language.getString(21219) + HTMLUtil.addColor(cache.loveTask.toPlayer.name, ColorConfig.instance.getCampColor(cache.loveTask.toPlayer.camp).color));
                        cache.loveTask.hasComment = true;
                        cache.loveTask.toPlayer = null;
                        if (isViewShow) 
                        {
                            view.hide();
                        }
                        else 
                        {
                            this.hideHintIcon();
                        }
                    }
                }
                else if (loc1.status == ETaskStatus._ETaskStatusHadCompleted) 
                {
                    this.showCommendView();
                }
                this.updateFreeCount();
            }
            return;
        }

        /* internal  */onTaskEndRes(arg1: Object): void
        {
            if (!arg1 || !arg1.task) 
            {
                return;
            }
            var loc1=arg1.task as TaskInfo;
            if (loc1.sTask.group == ETaskGroup._ETaskGroupLove) 
            {
                if (isViewShow) 
                {
                    view.hide();
                }
                this.hideHintIcon();
                cache.loveTask.fromPlayer = null;
                cache.loveTask.toPlayer = null;
            }
            return;
        }

        /* internal  */onTaskCancelRes(arg1: STask): void
        {
            if (!(arg1 && arg1.group == ETaskGroup._ETaskGroupLove)) 
            {
            };
            return;
        }

        /* internal  */onFriendListRes(arg1: Object): void
        {
            this.updateOnlinePlayer();
            return;
        }

        /* internal  */onFindPartnerRes(arg1: Object): void
        {
            this.updateOnlinePlayer();
            return;
        }

        /* internal  */onPartnerInfoRes(arg1: Object): void
        {
            if (this._taskResType == 1 && !cache.loveTask.hasComment) 
            {
                if (isViewShow) 
                {
                    this.onHintIconClickHandler(null);
                }
                else 
                {
                    this.showHintIcon(true);
                }
            }
            return;
        }

        /* internal  */onInvitePartnerRes(arg1: SPublicMiniPlayer): void
        {
            if (this._inviteView && !this._inviteView.isHide) 
            {
                this.addInviteView(arg1);
            }
            else 
            {
                this.showInviteIcon();
            }
            return;
        }

        /* internal  */onPartnerReplyRes(arg1: Object): void
        {
            var loc1=arg1 as SPartnerReply;
            MsgManager.showRollTipsMsg(HTMLUtil.addColor(loc1.fromPlayer.name, ColorConfig.instance.getCampColor(loc1.fromPlayer.camp).color) + Language.getString(21225));
            this.showGiveItemView();
            return;
        }

        /* internal  */onPartnerStartRes(arg1: Object): void
        {
            cache.loveTask.endMsg = false;
            cache.loveTask.toPlayerGiveItem = true;
            cache.loveTask.clearInvitePlayer();
            if (this._inviteView && !this._inviteView.isHide) 
            {
                this._inviteView.hide();
            }
            this.hideInviteIcon();
            if (cache.loveTask.isStartPlayer) 
            {
                this.showGiveItemView();
            }
            else if (cache.active.isActiveInEffect(EActiveType._EActiveTypeLoveGiffGaff)) 
            {
                cache.loveTask.toPlayerGiveItem = false;
                this.showGiveItemView();
            }
            else 
            {
                this.showGotoView(false);
            }
            return;
        }

        /* internal  */onPartnerEndRes(arg1: Object): void
        {
            var loc1=null;
            cache.loveTask.endMsg = true;
            cache.loveTask.toPlayerGiveItem = true;
            if (!cache.loveTask.isStartPlayer) 
            {
                cache.loveTask.fromPlayer = null;
                if (isViewShow) 
                {
                    view.hide();
                }
                loc1 = cache.task.getTaskByGroup(ETaskGroup._ETaskGroupLove);
                if (loc1.length > 0) 
                {
                    this.showHintIcon();
                }
                else 
                {
                    this.hideHintIcon();
                }
            }
            return;
        }

        /* internal  */onPartnerSentItemRes(arg1: Object): void
        {
            if (cache.loveTask.replyItem) 
            {
                if (cache.loveTask.fromPlayer) 
                {
                    MsgManager.showRollTipsMsg(HTMLUtil.addColor(cache.loveTask.fromPlayer.name, ColorConfig.instance.getCampColor(cache.loveTask.fromPlayer.camp).color) + Language.getStringByParam(21218, cache.loveTask.replyItem.htmlName));
                }
                else if (cache.loveTask.toPlayer) 
                {
                    MsgManager.showRollTipsMsg(HTMLUtil.addColor(cache.loveTask.toPlayer.name, ColorConfig.instance.getCampColor(cache.loveTask.toPlayer.camp).color) + Language.getStringByParam(21218, cache.loveTask.replyItem.htmlName));
                }
            }
            return;
        }

        /* internal  */onPartnerCommentRes(arg1: Object): void
        {
            this.showCommentIcon();
            return;
        }

        /* internal  */onEffectStartRes(arg1: Object): void
        {
            if (Game.isSceneInit()) 
            {
                Game.scene.udpateEffectIsAddToStage(cache.loveTask.sceneEffectId, true, 400101);
            }
            return;
        }

        private /* var */_hintIcon: HintIcon;

        private /* var */_inviteIcon: HintIcon;

        private /* var */_commentIcon: HintIcon;

        private /* var */_inviteView: ILoveTaskInviteModule;

        private /* var */_commentResView: ILoveTaskCommentResModule;

        private /* var */_taskResType: int;
    }
